package com.google.project.client.ProjectManager;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import com.google.gwt.core.client.GWT;
import com.google.gwt.core.client.Scheduler;
import com.google.gwt.uibinder.client.UiBinder;
import com.google.gwt.user.client.Window;
import com.google.gwt.user.client.rpc.AsyncCallback;
import com.google.gwt.user.client.ui.Composite;
import com.google.gwt.user.client.ui.Widget;
import com.google.gwt.uibinder.client.UiField;
import com.google.gwt.user.client.ui.Button;
import com.google.gwt.uibinder.client.UiHandler;
import com.google.gwt.event.dom.client.ClickEvent;
import com.google.gwt.user.datepicker.client.DateBox;
import com.google.gwt.user.client.ui.TextArea;
import com.google.project.client.Service.ProjTaskService;
import com.google.project.client.Service.ProjTaskServiceAsync;
import com.google.project.client.Service.ProjectService;
import com.google.project.client.Service.ProjectServiceAsync;
import com.google.project.client.Service.ProjectStaffService;
import com.google.project.client.Service.ProjectStaffServiceAsync;
import com.google.project.shared.CommonFuntion;
import com.google.project.shared.ProjectDTO;
import com.google.project.shared.ProjectStaffDTO;
import com.google.project.shared.ProjectTaskDTO;
import com.google.project.shared.SubConstructorDTO;
import com.google.project.shared.TaskConstrainDTO;
import com.google.gwt.user.client.ui.TextBox;
import com.google.gwt.user.client.ui.ListBox;
import com.google.gwt.view.client.MultiSelectionModel;
import com.google.gwt.event.dom.client.ChangeEvent;
import com.google.gwt.i18n.client.DateTimeFormat;
import com.google.gwt.user.client.ui.Label;

@SuppressWarnings("unused")
public class PMProjectTask extends Composite {

	private static final Binder binder = GWT.create(Binder.class);

	@UiField
	TextBox txtTaskName;
	@UiField
	TextBox txtAmountOfWork;
	@UiField
	ListBox cboUnit;
	@UiField
	ListBox cboSubcontructor;
	@UiField 
	TextArea txtDescription;
	@UiField
	DateBox dbStartDate;
	@UiField
	DateBox dbDueDate;
	@UiField
	Button btnCreateTask;
	@UiField
	Button button;
	@UiField
	TextBox txtWeight;
	@UiField
	ListBox cboTaskType;
	@UiField
	ListBox cboPanrentTask;
	@UiField Label lblTitle;
	

	interface Binder extends UiBinder<Widget, PMProjectTask> {
	}

	
	//_________________________Common varius___________________________________
	private ProjectDTO project = new ProjectDTO();
	private ProjectTaskDTO currTask= new  ProjectTaskDTO();
	private List<ProjectTaskDTO> listTask = new ArrayList<ProjectTaskDTO>();
	
	private final ProjectServiceAsync projectService = GWT.create(ProjectService.class);
	private final ProjectStaffServiceAsync projectStaffService = GWT.create(ProjectStaffService.class);
	private final ProjTaskServiceAsync ProjectTaskService = GWT.create(ProjTaskService.class);
  

	//END_________________________Common varius________________________________
	
	//___________________________Contructor____________________________________
	public PMProjectTask() {
		initWidget(binder.createAndBindUi(this));
		dbStartDate.setFormat(new DateBox.DefaultFormat(DateTimeFormat.getFormat("dd/MM/yyyy")));
		dbDueDate.setFormat(new DateBox.DefaultFormat(DateTimeFormat.getFormat("dd/MM/yyyy")));
		loadDataForCBO();
	}
	public PMProjectTask(ProjectDTO project) {
		initWidget(binder.createAndBindUi(this));
		this.project=project ;
		dbStartDate.setFormat(new DateBox.DefaultFormat(DateTimeFormat.getFormat("dd/MM/yyyy")));
		dbDueDate.setFormat(new DateBox.DefaultFormat(DateTimeFormat.getFormat("dd/MM/yyyy")));
	    lblTitle.setText("THÊM MỚI CÔNG VIỆC");
		projectService.getListTask(project.getProjectID(), new AsyncCallback<List<ProjectTaskDTO>>() {
			
			@Override
			public void onSuccess(List<ProjectTaskDTO> result) {
				listTask = result;
				loadDataForCBO();
			}
			
			@Override
			public void onFailure(Throwable caught) {
				// TODO Auto-generated method stub
			}
		});
	}
	
	public PMProjectTask(final String taskId, ProjectDTO project) {
		initWidget(binder.createAndBindUi(this));
		dbStartDate.setFormat(new DateBox.DefaultFormat(DateTimeFormat.getFormat("dd/MM/yyyy")));
		dbDueDate.setFormat(new DateBox.DefaultFormat(DateTimeFormat.getFormat("dd/MM/yyyy")));
		this.project=project ;
		  lblTitle.setText("CẬP NHẬT THÔNG TIN CÔNG VIỆC");
		projectService.getListTask(project.getProjectID(), new AsyncCallback<List<ProjectTaskDTO>>() {
			
			@Override
			public void onSuccess(List<ProjectTaskDTO> result) {
				listTask = result;
				for(ProjectTaskDTO task : listTask)
				{
					if(task.getId().equalsIgnoreCase(taskId))
					{
						currTask = task;
					}
				}
				displayData(currTask);
			}
			
			@Override
			public void onFailure(Throwable caught) {
				// TODO Auto-generated method stub
				
			}
		});
		// loadDataForCBO();
		
	}

	//End___________________________Contructor____________________________________

	//______________________________Common function_______________________________
	
	//----------------Get task from task list by task id--------------------------
	ProjectTaskDTO getTaskFromList(int taskId,List<ProjectTaskDTO> list)
	{
		for(ProjectTaskDTO task :list)
		{
			if(task.getTaskId()==taskId)
			{
				return task;
			}
		}
		return null;
	}
	//============================================================================
	
	//-----------------check task con valid for task cha--------------------------
	Boolean checkChildForParent(ProjectTaskDTO child ,ProjectTaskDTO parent )
	{
		//kiem tra ngay bat dau va ngay ket thuc cua tak hien tai
		/*if(child.getDueDate()>parent.getDueDate()||child.getStartDate()<parent.getStartDate())
		{
			Window.alert("Thời gian bắt đầu và kết thúc của công việc con không thể nằm ngoài khoảng thời gian của công việc cha.");
			return false;
		}*/
		
		if(child.getIsMile()==1)
		{
			if(child.getAmountOfWork()> parent.getAmountOfWork())
			{
				Window.alert("Khối lượng công việc của mốc mục tiêu không thể lớn hơn khối lượng công việc của công viecj cha");
				return false;
			}
		}
		return true;
	}
	//============================================================================
	//--------------------------Check input data for add--------------------------
	Boolean checkInputData()
	{
	    String taskName = txtTaskName.getValue();
		if(taskName==null||taskName.trim().equals(""))
		{
			Window.alert("Bạn phải nhập Tên công việc");
			Scheduler.get().scheduleDeferred(new Scheduler.ScheduledCommand () {
		        public void execute () {
		        	txtTaskName.setFocus(true);
		        }
		    });
			return false;
		}
		else
		{
			if(taskName.trim().length()>200)
			{
				Window.alert("Tên công việc không thể dài hơn 200 ký tự");
				Scheduler.get().scheduleDeferred(new Scheduler.ScheduledCommand () {
			        public void execute () {
			        	txtTaskName.setFocus(true);
			        }
			    });
				return false;
			}
		}
		
		
		//check khối lượng
	    String amountOfWork =txtAmountOfWork.getValue();
	    if(amountOfWork==null||amountOfWork.equals(""))
	    {
	    	Window.alert("Bạn phải nhập khối lượng công việc");
			Scheduler.get().scheduleDeferred(new Scheduler.ScheduledCommand () {
		        public void execute () {
		        	txtTaskName.setFocus(true);
		        }
		    });
			return false;
	    }
	    
	    try
	    {
	    	if(Double.parseDouble(amountOfWork)<=0&&!cboTaskType.getValue(cboTaskType.getSelectedIndex()).equals("1"))
	    	{
	    		Window.alert("Khối lượng công việc phải lớn hơn 0");
	    		Scheduler.get().scheduleDeferred(new Scheduler.ScheduledCommand () {
			        public void execute () {
			        	txtTaskName.setFocus(true);
			        }
			    });
	    		return false;
	    	}
	    }
	    catch(Exception ex)
	    {
	    	Window.alert("Khối lượng công việc phải là một số lớn hơn 0");
	    	Scheduler.get().scheduleDeferred(new Scheduler.ScheduledCommand () {
		        public void execute () {
		        	txtTaskName.setFocus(true);
		        }
		    });
	    	return false;
	    }
	    
	    String weight =txtWeight.getValue();
	    if(weight==null||weight.equals(""))
	    {
	    	Window.alert("Bạn phải nhập trọng số công việc");
			Scheduler.get().scheduleDeferred(new Scheduler.ScheduledCommand () {
		        public void execute () {
		        	txtWeight.setFocus(true);
		        }
		    });
			return false;
	    }
	    
	    try
	    {
	    	if(Double.parseDouble(weight)<0)
	    	{
	    		Window.alert("Trọng số công việc không thể nhỏ hơn 0");
	    		Scheduler.get().scheduleDeferred(new Scheduler.ScheduledCommand () {
			        public void execute () {
			        	txtWeight.setFocus(true);
			        }
			    });
	    		return false;
	    	}
	    }
	    catch(Exception ex)
	    {
	    	Window.alert("Trọng số công việc phải là một số ");
	    	Scheduler.get().scheduleDeferred(new Scheduler.ScheduledCommand () {
		        public void execute () {
		        	txtWeight.setFocus(true);
		        }
		    });
	    	return false;
	    }
	    
	    if(dbStartDate.getValue()==null)
	    {
	    	Window.alert("Ngày bắt đầu không đúng định dạng ");
	    	Scheduler.get().scheduleDeferred(new Scheduler.ScheduledCommand () {
		        public void execute () {
		        	dbStartDate.setFocus(true);
		        }
		    });
	    	return false;
	    }
	    
	    if(CommonFuntion.removeTime(dbStartDate.getValue())< CommonFuntion.removeTime(new Date(project.getStartDate())))
		{
	Window.alert("Ngày bắt đầu công việc không được nhỏ hơn ngày bắt đầu dự án ");
	Scheduler.get().scheduleDeferred(new Scheduler.ScheduledCommand () {
        public void execute () {
        	dbStartDate.setFocus(true);
        }
    });
	return false;
		}
	    
	   
	    if(currTask.getId()==null||currTask.getId().equals(""))
	    {
//	    	Date checkDate =  new Date();
//	    	if(CommonFuntion.removeTime(dbStartDate.getValue())< CommonFuntion.removeTime(checkDate))
//	    			{
//	    		Window.alert("Ngày bắt đầu không được nhỏ hơn ngày hiện tại ");
//		    	Scheduler.get().scheduleDeferred(new Scheduler.ScheduledCommand () {
//			        public void execute () {
//			        	dbStartDate.setFocus(true);
//			        }
//			    });
//		    	return false;
//	    			}
	    }
	    else
	    {
	    	
	    	if(CommonFuntion.removeTime(dbStartDate.getValue()).longValue()!=CommonFuntion.removeTime(new Date(currTask.getStartDate())).longValue())
	    	{
	    		Date checkDate =  new Date();
//		    	if(CommonFuntion.removeTime(dbStartDate.getValue())< CommonFuntion.removeTime(checkDate))
//		    			{
//		    		Window.alert("Ngày bắt đầu không được nhỏ hơn ngày hiện tại ");
//			    	Scheduler.get().scheduleDeferred(new Scheduler.ScheduledCommand () {
//				        public void execute () {
//				        	dbStartDate.setFocus(true);
//				        }
//				    });
//			    	return false;
//		    			}
	    	}
	    }
	    
	    
	    if(cboTaskType.getValue(cboTaskType.getSelectedIndex()).equals("0"))
	    {
	    if(dbDueDate.getValue()==null)
	    {
	    	Window.alert("Ngày Kết thúc không đúng định dạng ");
	    	Scheduler.get().scheduleDeferred(new Scheduler.ScheduledCommand () {
		        public void execute () {
		        	dbDueDate.setFocus(true);
		        }
		    });
	    }
	    
	    if(!cboTaskType.getValue(cboTaskType.getSelectedIndex()).equals("1")&&CommonFuntion.removeTime(dbStartDate.getValue())>CommonFuntion.removeTime(dbDueDate.getValue()))
	    {
	    	Window.alert("Ngày bắt đầu không được vượt quá ngày kết thúc ");
	    	Scheduler.get().scheduleDeferred(new Scheduler.ScheduledCommand () {
		        public void execute () {
		        	dbStartDate.setFocus(true);
		        }
		    });
	    	return false;
	    }
	    }
	//warning
	    if(!cboTaskType.getValue(cboTaskType.getSelectedIndex()).equals("1")&& CommonFuntion.removeTime(dbDueDate.getValue())> CommonFuntion.removeTime(new Date(project.getDueDate())))
		{
	Window.alert("Ngày kết thúc công việc không được lớn hơn ngày kết thúc dự án ");
	Scheduler.get().scheduleDeferred(new Scheduler.ScheduledCommand () {
        public void execute () {
        	dbDueDate.setFocus(true);
        }
    });
	return false;
		}
	    
		if(cboUnit.getValue(cboUnit.getSelectedIndex()).equals("0")
				&&cboTaskType.getValue(cboTaskType.getSelectedIndex()).equals("0"))
		{
			Window.alert("Bạn phải chọn đơn vị");
			return false;
		}
	    
		return true;
	}
	//----------------------------------------------------------------------------
	
	//----------------------get total weight of sub task--------------------------
	Boolean checkTotalWeight(ProjectTaskDTO task,List<ProjectTaskDTO> list)
	{
		Double total =0d;
		if(task.getParentId()!=0)
		{
			
			ProjectTaskDTO parentTask = getTaskFromList(task.getParentId(), list);
			
			for(ProjectTaskDTO obj : list)
			{
				if(parentTask.getSubTasks()!=null&&CommonFuntion.checkContain(parentTask.getSubTasks(),obj.getTaskId()+""))
				{
					if(task.getId()!=null&&!task.getId().equalsIgnoreCase("")||(obj.getStatus()==3||obj.getId().equals(task.getId())))
					{
						continue;
					}
					total +=obj.getWeight();
				}
			}
			
			if(total+task.getWeight()>100)
			{
				Window.alert("Tổng trọng số của công việc cha không thể lớn hơn 100%");
				return false;
			}
		}
		else
		{

			for(ProjectTaskDTO obj : list)
			{
				if(task.getId()!=null&&!task.getId().equalsIgnoreCase("")||(obj.getStatus()==3||obj.getId().equals(task.getId())))
				{
					continue;
				}
				if(obj.getParentId()==0)
				{
					total +=obj.getWeight();
				}
			}
			
			if(total+task.getWeight()>100)
			{
				Window.alert("Tổng trọng số của dự án không thể lớn hơn 100%");
				return false;
			}
		}
		
		
		return true;
	
	}
	//============================================================================
	//-------------------display data for update task-----------------------------
	void displayData(ProjectTaskDTO result) {
		loadDataForCBO();
		if (result.getGroup() == 1) {
			//txtWeight.setEnabled(false);
			//txtAmountOfWork.setEnabled(false);
			//cboUnit.setEnabled(false);
			cboTaskType.setEnabled(false);
			cboSubcontructor.setEnabled(false);
			
		}
		if(result.getIsMile()==1)
		{
			txtWeight.setEnabled(false);
			dbDueDate.setEnabled(false);
			
			cboSubcontructor.setEnabled(false);
			cboUnit.setEnabled(false);
			cboPanrentTask.setEnabled(false);
		
			
		}
		txtTaskName.setValue(result.getTaskName());
		txtAmountOfWork.setValue(result.getAmountOfWork().toString());
		txtDescription.setValue(result.getDescription());
		txtWeight.setValue(result.getWeight().toString());
		dbDueDate.setValue(new Date(result.getDueDate()));
		dbStartDate.setValue(new Date(result.getStartDate()));
	}
	//===================================================================

	//------------------load data for all combobox-----------------------
	public void loadDataForCBO() {
		
		//load data for list subcontructor
		projectService.getListSubContructor(this.project.getProjectID(),new AsyncCallback<List<SubConstructorDTO>>() {
					@Override
					public void onSuccess(List<SubConstructorDTO> result) {
						// TODO Auto-generated method stub
						cboSubcontructor.addItem("Lựa chọn", "0");
						
						if (result != null && result.size() > 0) {

							for (SubConstructorDTO subcontructor : result) {
								cboSubcontructor.addItem(subcontructor.getConstructorName()
										,subcontructor.getConstructorId());
							}
						}
                        
						if (currTask != null) {
							if (currTask.getSubContructor()!=null&&!currTask.getSubContructor().equalsIgnoreCase("")) {
							for (int m = 0; m < cboSubcontructor.getItemCount(); m++) {
								String subcontructor = cboSubcontructor.getItemText(m);
								
								if (subcontructor.equalsIgnoreCase(currTask.getSubContructor())) {
									cboSubcontructor.setSelectedIndex(m);
									break;

								}
							}
							}
						}
					}

					@Override
					public void onFailure(Throwable caught) {
						// TODO Auto-generated method stub

					}
				});
	
		
		//load data for list task

		cboPanrentTask.addItem("Lựa chọn", "0");
		String listSub = "";
		if (listTask != null && listTask.size() > 0) {
			
			
			if (currTask!=null&&currTask.getGroup() == 1) {
				listSub = getAllOfSub(currTask.getSubTasks(), listTask);
			}
			for (ProjectTaskDTO task : listTask) {
                //neu task khong co rang buoc 
				if(task.getStatus()!=3)
				{
				if (task.getDependent() == null|| task.getDependent().length() < 2) {
                    
					if (!CommonFuntion.checkContain(listSub,"" + task.getTaskId())&& task.getIsMile() == 0) {
						
						if(currTask!=null)
						{
							if(task.getTaskId() != currTask.getTaskId())
							{
								cboPanrentTask.addItem(task.getTaskName(), ""+ task.getTaskId());
							}
						}
						else
						{
							cboPanrentTask.addItem(task.getTaskName(), ""+ task.getTaskId());
						}
				
					}

				}
				}

			}
		}

		if (currTask != null) {
			for (int l = 0; l < cboPanrentTask.getItemCount(); l++) {
				if (cboPanrentTask.getValue(l).equalsIgnoreCase(
						currTask.getParentId() + "")) {
					cboPanrentTask.setSelectedIndex(l);
					break;

				}
			}
		}

		if(currTask.getOptUserId()==null)
		{
			currTask.setOptUserId("0");
			currTask.setOptAccountName("");
		}
		//load data for task type
		cboTaskType.addItem("Lựa chọn", "0");
		cboTaskType.addItem("MileStone", "1");
		
		if (currTask != null) {
			for (int j = 0; j < cboTaskType.getItemCount(); j++) {
				if (cboTaskType.getValue(j).equalsIgnoreCase(currTask.getIsMile() + "")) 
				{
					cboTaskType.setSelectedIndex(j);
					break;

				}
			}
		}

		//load data for unit
		cboUnit.addItem("Lựa chọn", "0");
		cboUnit.addItem("M", "M");
		cboUnit.addItem("M2", "M2");
		cboUnit.addItem("M3", "M3");
		cboUnit.addItem("Ca máy", "Ca máy");
		cboUnit.addItem("Chiếc", "Chiếc");
		cboUnit.addItem("Cái", "Cái");
		
		if (currTask != null) {
			for (int i = 0; i < cboUnit.getItemCount(); i++) {
				if (cboUnit.getItemText(i).equalsIgnoreCase(currTask.getUnit())) {
					cboUnit.setSelectedIndex(i);
					break;

				}
			}
		}
	}
//==============================================================================

//-------------------------get all sub task of task-----------------------------
	private String getAllOfSub(String sub, List<ProjectTaskDTO> listTask) {
		String newSub = "";
		for (ProjectTaskDTO temp : listTask) {
			if (CommonFuntion.checkContain(sub,temp.getTaskId() + "")) {
				if (newSub.equalsIgnoreCase("")) {
					newSub += temp.getSubTasks();
				} else {
					newSub += "," + temp.getSubTasks();
				}
			}
		}
		if (!newSub.equalsIgnoreCase("")) {
			sub += getAllOfSub(newSub, listTask);
		}

		return sub;
	}

	
//___________________________________________Event ____________________________________
	
	//su kien click button to add task
	@UiHandler("btnCreateTask")
	void onBtnCreateTaskClick(ClickEvent event) {
		//lay du lieu tu form truyen ve 
		if(checkInputData())
		{
			if(	currTask ==null)
			{
				currTask = new ProjectTaskDTO();
			}
			Long startDate = CommonFuntion.removeTime(new Date(dbStartDate.getValue().getTime()));
			Long dueDate=0l;
			if(dbDueDate.getValue()!=null )
			{
				 dueDate =CommonFuntion.removeTime(new Date(dbDueDate.getValue().getTime())); 
			}
			
			int isMile = Integer.parseInt(cboTaskType.getValue(cboTaskType.getSelectedIndex()));
			
			currTask.setTaskName(txtTaskName.getText());
			currTask.setStartDate(startDate);
			currTask.setDescription(txtDescription.getText());
			currTask.setAmountOfWork(Double.parseDouble(txtAmountOfWork.getText()));
			currTask.setProjectId(this.project.getProjectID());
			currTask.setUnit(cboUnit.getValue(cboUnit.getSelectedIndex()));
			if(isMile==1)
			{
				
				currTask.setWeight(0d);
			}
			else
			{
				currTask.setWeight(Double.parseDouble(txtWeight.getValue()));
			}
			
			if(cboSubcontructor.getValue(cboSubcontructor.getSelectedIndex()).equals("0"))
			{
				currTask.setSubContructor("");
			}
			else
			{
			currTask.setSubContructor(cboSubcontructor.getItemText(cboSubcontructor.getSelectedIndex()));
			}
			
			
			currTask.setParentId(Integer.parseInt(cboPanrentTask.getValue(cboPanrentTask.getSelectedIndex())));
			currTask.setIsMile(isMile);
			
			//neu chua co gia tri mac dinh thi gan gia tri mac dinh
			if (currTask.getFinishedWork() == null) {
				currTask.setFinishedWork(0d);
			}
			
			
			//neu la mistone xet trong so =0
			Boolean checkData =true ;
			//neu task hien tai co cha
			if(currTask.getParentId()!=0)
			{
				//lay ve task cha 
				ProjectTaskDTO parentTask = new ProjectTaskDTO();
				parentTask = getTaskFromList(currTask.getParentId(), listTask);
				if(parentTask!=null)
				{
					
					checkData = checkChildForParent(currTask, parentTask);
					currTask.setUnit(parentTask.getUnit());
				}
				
			}
		
			
			if(checkData)
			{
				if(checkTotalWeight(currTask, listTask))
				{
						//neu la up date  kiem tra xem thoi gian ket thuc co thay doi khong
						if(currTask.getId()!=null)
						{
							
								Boolean okForCallUpdate =true;
								if(CommonFuntion.removeTime(new Date( currTask.getDueDate()))<CommonFuntion.removeTime(new Date(dueDate)))
								{
									if(currTask.getDependent()!=null)
									{
										String afterData = currTask.getDependent().substring(currTask.getDependent().indexOf("|"));
										
										if(afterData.length()>1)
										{
											afterData=afterData.substring(1);
										}
										else
										{
											afterData="";
										}	
									
										if(!afterData.equals(""))
										{
											Boolean okForChangePlan = false;
											for(ProjectTaskDTO task : listTask)
											{
												if(CommonFuntion.checkContain(afterData,task.getTaskId()+""))
												{
													if(CommonFuntion.removeTime(new Date( task.getStartDate()))<=CommonFuntion.removeTime(new Date(dueDate)))
													{
														okForChangePlan =true;
														break;
														
													}
													
												}
											}
											
											if(okForChangePlan)
											{
												okForCallUpdate=false;
												String message ="Thay đổi thời gian kết thúc của công việc sẽ làm ảnh hưởng đến kế hoạch các công việc khác . Bạn có muốn tiếp tục?";
												
												if(Window.confirm(message))
												{
													Long dateDiff = CommonFuntion.removeTime( new Date( dueDate)) - CommonFuntion.removeTime( new Date( currTask.getDueDate()));
													dateDiff = dateDiff/(24*60*60*1000);
													//currTask.setDueDate(dueDate);
													tree dialog = new tree(currTask,dateDiff.intValue());
													dialog.setPopupPosition(350, 100);
													dialog.show();
												}
											}
										
										}
									}
								}
								if(okForCallUpdate)
								{
									if(currTask.getIsMile()==1)
									{
										currTask.setDueDate(startDate);
									}
									else
									{
										currTask.setDueDate(dueDate);
									}
									callUpdate();
								}
							
						}
						else
						{
							if(currTask.getIsMile()==1)
							{
								currTask.setDueDate(startDate);
							}
							else
							{
								currTask.setDueDate(dueDate);
							}
						
						// truyen du lieu len server xu ly
						callUpdate();
					}
				
				}
			}

		}

	}
	void callUpdate()
	{
		ProjectTaskService.CreateTask(currTask, listTask,
				new AsyncCallback<ProjectTaskDTO>() {

					@Override
					public void onSuccess(ProjectTaskDTO result) {
						// TODO Auto-generated method stub
						if(currTask.getIsMile()==0)
						{
							if(Window.confirm("Thực hiện thành công, ban có muốn tiếp tục bước 2 không ?"))
							{
								PMEntrypoint.get().PMProjectTaskStep2(result,project.getProjectID(),0);
							}
							else
							{
								PMEntrypoint.get().PMCreateProjectPlan(project.getProjectID());
							}
						}
						else
						{
							Window.alert("Thực hiện thành công");
							PMEntrypoint.get().PMCreateProjectPlan(project.getProjectID());
						}
						
					}

					@Override
					public void onFailure(Throwable caught) {
						// TODO Auto-generated method stub
					}
				});
	}
	
	//su kien tro ve trang danh sach cong viec (projectCreatePlan)
	@UiHandler("button")
	void onButtonClick(ClickEvent event) {
		PMEntrypoint.get().PMCreateProjectPlan(project.getProjectID());
	}
	
	// su kien chon mistone
	@UiHandler("cboTaskType")
	void onCboTaskTypeChange(ChangeEvent event) {
		if(cboTaskType.getValue(cboTaskType.getSelectedIndex()).equalsIgnoreCase("1"))
		{
			txtWeight.setValue("0");
			txtWeight.setEnabled(false);
			cboPanrentTask.setEnabled(false);
			cboPanrentTask.setSelectedIndex(0);
			txtAmountOfWork.setEnabled(false);
			txtAmountOfWork.setText("0");
			dbDueDate.setValue(dbStartDate.getValue());
			dbDueDate.setEnabled(false);
			
			cboSubcontructor.setSelectedIndex(0);
			cboSubcontructor.setEnabled(false);
			cboUnit.setSelectedIndex(0);
			cboUnit.setEnabled(false);
		}
		else
		{
			txtWeight.setEnabled(true);
			dbDueDate.setEnabled(true);
			
			cboSubcontructor.setEnabled(true);
			cboUnit.setEnabled(true);
			txtAmountOfWork.setEnabled(true);
			cboPanrentTask.setEnabled(true);
		}
	}
}
